// handlers/monitorHandler.js
// 长期监控处理器 - 扫描并检查所有运行中的任务
// 职责：接管超过5分钟的任务监控
// 应由定时触发器或管理员手动调用

const cloud = require('wx-server-sdk');
const db = cloud.database();
const _ = db.command;

const { getTaskMonitor } = require('../monitors/TaskMonitor');

/**
 * 长期监控处理函数
 * 扫描所有运行中的任务，根据年龄智能检查
 */
async function handle(event, context) {
  console.log('📊 执行长期监控 - 扫描运行中的任务');

  try {
    // 1. 查询所有运行中的任务（有 executeId 的）
    const result = await db.collection('video_tasks')
      .where({
        status: _.in(['running', 'rendering']),
        executeId: _.neq(null)
      })
      .limit(100)
      .get();

    const tasks = result.data;
    console.log(`找到 ${tasks.length} 个运行中的任务`);

    if (tasks.length === 0) {
      return {
        success: true,
        message: '没有需要监控的任务',
        checkedCount: 0
      };
    }

    // 2. 根据任务年龄和上次检查时间智能检查
    const monitor = getTaskMonitor();
    const results = {
      checked: 0,
      skipped: 0,
      completed: 0,
      failed: 0
    };

    const now = new Date();

    for (const task of tasks) {
      const taskId = task.taskId;
      
      // 计算任务年龄（从创建到现在）
      const ageMinutes = monitor.getTaskAge(task);
      
      // 计算距离上次检查的时间（从更新时间到现在）
      const createdAt = new Date(task.createdAt);
      const updatedAt = task.updatedAt ? new Date(task.updatedAt) : createdAt;
      const minutesSinceLastCheck = (now - updatedAt) / 1000 / 60;

      // 超过1天（1440分钟）的任务不再检查
      if (ageMinutes >= 1440) {
        results.skipped++;
        console.log(`⏭️ 跳过任务 ${taskId} (年龄: ${ageMinutes.toFixed(1)}分钟，超过24小时，停止监控)`);
        continue;
      }

      // 根据任务年龄决定检查间隔
      let checkInterval = 1; // 默认每分钟检查
      
      if (ageMinutes < 5) {
        // 0-5分钟：每1分钟检查
        checkInterval = 1;
      } else if (ageMinutes < 20) {
        // 5-20分钟：每2分钟检查
        checkInterval = 2;
      } else if (ageMinutes < 120) {
        // 20-120分钟：每5分钟检查
        checkInterval = 5;
      } else {
        // 120-1440分钟：每10分钟检查
        checkInterval = 10;
      }

      // 判断是否需要检查：距上次检查时间 >= 检查间隔
      const shouldCheck = minutesSinceLastCheck >= checkInterval;

      if (shouldCheck) {
        try {
          console.log(`🔍 检查任务 ${taskId} (年龄: ${ageMinutes.toFixed(1)}分钟, 距上次检查: ${minutesSinceLastCheck.toFixed(1)}分钟)`);
          
          // 检查任务状态
          const updatedTask = await monitor.checkTask(taskId);

          // 统计结果
          if (updatedTask) {
            if (updatedTask.status === 'completed') {
              results.completed++;
            } else if (updatedTask.status === 'failed') {
              results.failed++;
            }
          }

          // 无论状态是否变化，都更新 updatedAt，记录本次检查时间
          await db.collection('video_tasks')
            .where({
              taskId: taskId
            })
            .update({
              data: {
                updatedAt: db.serverDate()
              }
            });

          results.checked++;
        } catch (error) {
          console.error(`❌ 检查任务 ${taskId} 失败:`, error);
        }
      } else {
        results.skipped++;
        console.log(`⏭️ 跳过任务 ${taskId} (年龄: ${ageMinutes.toFixed(1)}分钟, 距上次检查: ${minutesSinceLastCheck.toFixed(1)}分钟，未到检查间隔 ${checkInterval}分钟)`);
      }
    }

    console.log(`✅ 监控完成:`, results);

    return {
      success: true,
      message: '长期监控执行完成',
      totalTasks: tasks.length,
      results
    };

  } catch (error) {
    console.error('❌ 监控任务失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
}

module.exports = handle;

